/**
 * 事件处理方法
 */
import {getYsdApiData} from '@/views/youshuda/api/BaseApi'
import request from "@/utils/request";
import {strIsNotEmpty, escapeDeal, generateUuid} from "@/views/youshuda/utils/youshuda";
import store from "@/store";
import {login} from "@/api/login";
import {setToken} from "@/utils/auth";

export const EventMixins = {
  components: {
  },
  props: {
  },
  computed: {},
  data() {
    return {
      // 表单参数
      form: {},
      // 事件运行时作用域     列表查询区域为 true、表单操作区域为false
      isQueryScope: false,
      //表单组件是否有效标识
      FormComponentActive: true,
      //表单设计字段配置信息
      formBuildConfig: [],
      //对象中下拉框
      formDataOptions: {},
      //表单字段组件类型
      formColumnType: {},
      //表单字段组件名字
      formColumnNameInfo: {},
      //当前操作的数据行
      rowData:null,
      //当前选择的行数据
      selectRowData:[],
      //需要展示的错误信息
      alertInfo:{
        alertType: '',
        alertContent: ''
      }
    }
  },
  created() {
  },
  methods: {
    /**
     * ==============================表单组件事件处理==============================
     */
    /** 重新加载表单信息 **/
    refreshForm() {
      this.FormComponentActive = false;
      this.$nextTick(() => {
        this.FormComponentActive = true;
      });
    },
    /** 执行事件对应逻辑 **/
    evalEventCode(eventCode,rowData) {
      this.rowData = rowData ? rowData : null
      if (eventCode) {
        /** 特殊字符处理 **/
        eventCode = escapeDeal(eventCode);
        // 创建函数对象
        const func = new Function(eventCode);
        return func.call(this);
      }
    },
    /** 消息提示，展示在表单顶部 **/
    msgAlert(type,info){
      this.alertInfo={
        alertType:type,
        alertContent: info
      }
    },
    /** 获取当前登录用户 **/
    getUserName() {
      return store.getters.name;
    },
    /** 获取当前登录用户角色 **/
    getUserRoles() {
      return store.getters.roles;
    },
    /** 获取表单字段值 **/
    getFieldValue(fieldName) {
      if (fieldName) {
        return this.form[fieldName]
      }
      return '';
    },
    /** 设置表单字段值 **/
    setFieldValue(fieldName, fieldValue) {
      if (fieldName) {
        this.$set(this.form, fieldName, fieldValue)
        this.changeFieldConfigValue(fieldName, 'fieldValue', fieldValue, true)
      }
    },
    /** 显示表单字段 **/
    showField(fieldName) {
      this.changeFieldConfigValue(fieldName, 'isShow',true)
    },
    /** 隐藏表单字段 **/
    hideField(fieldName) {
      this.changeFieldConfigValue(fieldName, 'isShow',false)
    },
    /** 设置禁用 **/
    setDisabled(fieldName) {
      this.changeFieldConfigValue(fieldName, 'disabled',true)
    },
    /** 取消禁用 **/
    cancelDisabled(fieldName) {
      this.changeFieldConfigValue(fieldName, 'disabled',false)
    },
    /** 改变element对象值 **/
    changeFieldConfigValue(fieldName, key, val, isDealOnChangeEvent) {
      if(!Array.isArray(this.formBuildConfig)){
        return;
      }
      let that = this
      if (this.strIsEmpty(fieldName)) {
        this.msgError("处理字段不能为空");
        return;
      }
      let isFind=false;
      function findColumn(formBuildConfig){
        for (let field of formBuildConfig) {
          if (field && (field['vModel'] == fieldName || field['formId'] == fieldName)) {
            that.$set(field, key, val)
            //如果是修改字段值，则需要同时修改defaultValue
            if(key == 'fieldValue'){
              that.$set(field, 'defaultValue', val)
              /** 当存在onChange事件处理时，则处理相关 **/
              if(isDealOnChangeEvent && field['onChange']){
                that.evalEventCode(field['onChange']);
              }
            }
            isFind=true;
            return;
          }
          if(field.children && Array.isArray(field.children) && field.children.length>0){
            findColumn(field.children)
            if(isFind){
              return;
            }
          }
        }
      }
      findColumn(this.formBuildConfig);
    },
    /**
     * 修改组件选项
     * 1、根据平台字典管理中字典编码进行修改
     * 参数：("组件属性", "字典编码");
     * 2、根据请求优树搭API获取选项进行修改，参数列表为空时需要传递{}
     * 参数：("组件属性", "优树搭API", {'参数': "参数1"});
     * 3、直接传递选项数组，这种情况平台不考虑翻译问题
     * 参数：("组件属性", [{dictLabel: "是", dictValue: "0"}, {dictLabel: "否", dictValue: "1"}]);
     */
    setSelectionOptions(fieldName, dictObj, otherParam){
      /** 当字典参数为空或即不是数组也不是字符串时，默认为无效选项直接赋值空数组 **/
      if (dictObj == null || dictObj == undefined || (!Array.isArray(dictObj) && typeof dictObj !== 'string')) {
        dictObj = []
      }
      /** 字典参数为数组时，直接修改到组件上 **/
      if(Array.isArray(dictObj)){
        // 字典选项
        this.$set(this.formDataOptions, fieldName, dictObj)
        this.changeFieldConfigValue(fieldName, 'options', dictObj)
        return;
      }
      /** 字典参数为字符串时，请求服务器获取字典信息再修改到组件上 **/
      if(typeof dictObj === 'string'){
        if(otherParam){
          // 请求优树搭获取字典选项信息
          getYsdApiData(dictObj,otherParam).then(response=>{
            let parseOptions=[]
            if(response.data && Array.isArray(response.data)){
              parseOptions = response.data
            }
            this.$set(this.formDataOptions, fieldName, parseOptions)
            this.changeFieldConfigValue(fieldName, 'options', parseOptions)
            return;
          });
        }else{
          // 获取平台字典编码
          this.getDicts(dictObj).then(response => {
            let parseOptions=[]
            if(Array.isArray(response.data)){
              parseOptions=response.data
            }
            this.$set(this.formDataOptions, fieldName, parseOptions)
            this.changeFieldConfigValue(fieldName, 'options', parseOptions)
            return;
          })
        }
      }
    },
    /** Get请求服务器数据 **/
    axiosGet(url) {
      if (!this.strIsNotEmpty(url)) {
        this.msgError("Get请求地址不能为空");
        return;
      }
      return request({url: url, method: 'get'})
    },
    /** Post请求服务器数据 **/
    axiosPost(url, data) {
      if (!this.strIsNotEmpty(url)) {
        this.msgError("Post请求地址不能为空");
        return;
      }
      return request({url: url, method: 'post', data: data})
    },
    /** 请求优树搭接口数据 **/
    getYsdApiData(procTarget,reqData){
      if (!this.strIsNotEmpty(procTarget)) {
        this.msgError("优树搭API编码不能为空");
        return;
      }
      return getYsdApiData(procTarget,reqData);
    },
    /** 请求优树搭接口进行数据导出 */
    handleExportByYsd(procTarget,reqData,fileName) {
      //请求地址
      let ysdUrl = '/MksAp/ProcRun/dealToExport?reqTag='+generateUuid()+"&procTarget="+procTarget
      //文件名字
      fileName =  fileName || `${new Date().getTime()}.xlsx`
      this.download(ysdUrl, {
        ...reqData
      }, fileName)
    },
    /** 打开自定义对话框 **/
    openCustomDialog(config){
      const CustomDialog = this.$options.components['CustomDialog'];
      const dialogInstance = new CustomDialog({
        el: document.createElement('div')
      });
      document.body.appendChild(dialogInstance.$el);
      dialogInstance.open(config);
      dialogInstance.$on('submit', () => {
        if(config && config.submitCallback && typeof config.submitCallback === 'function'){
          config.submitCallback.call(this);
        }
      });
      dialogInstance.$on('cancel', () => {
        if(config && config.cancelCallback && typeof config.cancelCallback === 'function'){
          config.cancelCallback.call(this);
        }
      });
    },


    /**
     * ==============================表单数据处理==============================
     */
    /** 同步数据 **/
    ItemValChange(data) {
      this.form[data.key] = data.val
    },
    /**
     * 同步表单值
     **/
    changeFormData(item) {
      if (item == null || item == undefined) {
        return
      }
      //需要展示的错误信息
      if (item['type'] === 'AlertInfo') {
        this.alertInfo=item
        return;
      }

      let fieldName = item.key;
      /**
       * 下拉框联动的情况
       */
      if(['radio','select','checkbox'].includes(item['type'])){
        let _fieldValue = item.val;
        //值转成成以逗号隔开的字符串
        if (_fieldValue instanceof Array) {
          _fieldValue = _fieldValue.filter(Boolean).join(',')
        }
        this.$set(this.form, fieldName, _fieldValue)
        this.getLinkVModelOption(item)
      }else{
        this.$set(this.form, fieldName, item.val)
      }
      if(item['changeFieldConfig'] != false){
        this.changeFieldConfigValue(fieldName, 'fieldValue', item.val)
      }
    },
    /**
     * 下拉框联动的情况，获取联动下拉框选项数据
     * 返回结构：[{dictLabel: "是", dictValue: "0"}, {dictLabel: "否", dictValue: "1"}]
     */
    getLinkVModelOption(obj) {
      let that = this
      if(obj['config'] == null || obj['config'] == undefined){
        return;
      }
      //联动字段选项集合key
      let itemKey = obj['config']['linkVModel']
      //联动字段选项集合key
      let linkVModelOptionUrl = obj['config']['linkVModelOptionUrl']
      //联动请求方式
      let linkVModelOptionReqType = obj['config']['linkVModelOptionReqType']
      if (!this.strIsNotEmpty(linkVModelOptionUrl) || !this.strIsNotEmpty(linkVModelOptionReqType)) {
        return
      }
      //当下拉框未选择是，清空被联动的下拉框
      if (!this.strIsNotEmpty(obj['val'])) {
        that.dealLinkVModelOption(itemKey, [])
      } else {
        if (linkVModelOptionReqType.toUpperCase() == 'POST') {
          //POST方式
          //发送请求
          this.axiosPost(linkVModelOptionUrl, {'dictType': obj['val']}).then(res => {
            that.dealLinkVModelOption(itemKey, res.data)
          })
        } else {
          //GET方式
          //发送请求
          this.axiosGet(linkVModelOptionUrl + '/' + obj['val']).then(res => {
            that.dealLinkVModelOption(itemKey, res.data)
          })
        }
      }
    },
    /**
     * 处理被联动的下拉组件选择、值信息
     */
    dealLinkVModelOption(itemKey, optionData) {
      //重新赋值下拉选项
      this.$set(this.formDataOptions, itemKey, optionData)
      this.changeFieldConfigValue(itemKey, 'options', optionData)
    },

    /** 记录表单中类型为下拉框、多选框、单选框的选项值
     * 选项值集结构：[{dictLabel: "是", dictValue: "0"}, {dictLabel: "否", dictValue: "1"}]
     **/
    recordSelectionOptions(dictType, options){
      if (options == null || options == undefined) {
        options = []
      }
      this.$set(this.formDataOptions, dictType, options)
    },
    /**
     * 记录表单字段组件类型
     * @param column
     * @param type
     */
    recordFormColumnType(column, type){
      //表单字段组件类型
      this.$set(this.formColumnType, column, type)
    },
    /**记录表单字段组件类型**/
    recordFormColumnName(column, name){
      //表单字段组件类型
      this.$set(this.formColumnNameInfo, column, name)
    },

  },
  watch: {

  }
}
